'''
@since: 21.03.2014

@author: Max
@summary: Die Klasse Map baut eine Map aufgrund eines .tmx-Files und einem gegebenen Tileset
'''

from gfx.Tile import *    # @UnusedWildImport
from gfx.Tileset import *    # @UnusedWildImport
from Solids import *    # @UnusedWildImport
from Properties import *    # @UnusedWildImport
from ai.Worker import *    # @UnusedWildImport


class Map(object):
    def __init__(self, tileset, clock):
        """
        @param tileset: String-Pfad zum Tileset-Bild
        """
        self.Tileset = Tileset(tileset)
        """@ivar: Tileset enthaelt das Array mit einzelnen Tile-Bildern"""
        
        self.surface = pygame.Surface([MAP_WIDTH, MAP_HEIGHT]).convert()
        self.surface.set_colorkey(COLOR_BLACK)
        """@ivar: Surface ist die Leinwand, auf welcher die Map gezeichnet wird"""        
        
        self.surfaceProps = pygame.Surface([MAP_WIDTH, MAP_HEIGHT]).convert()
        self.surfaceProps.set_colorkey(COLOR_BLACK)
        """@ivar: Surface ist die Leinwand, auf welcher die Map gezeichnet wird"""
        
        self.arMapTiles = []
        """@ivar: Ein Array, das alle Tiles der Map in richtiger Reihenfolge enthaelt"""
        
        self.x = MAP_SURFACE_X_VALUE
        self.y = MAP_SURFACE_Y_VALUE
        
        self.arMapProps = []
        """@ivar: Ein Array, das alle Prop-Tiles, wie NPC, Waende etc. enthaelt"""
    
        self.clock = clock
    
        self.worker = Worker((0, 0), self, clock)
        self.arMapProps.append(self.worker)
        
        self.arAstar = []
        
        
    def loadMap(self, tmxMap = 0):
        """
        Diese Funktion laed die Map. Derzeit wird eine reine Sandmap geladen, bei der jedes Tile begehbar ist.
        
        @param tmxMap: String-Pfad zum tmx-File
        @todo: TMX-Unterstuetzung
        @version: 0.1
        """
        tileImg = self.Tileset.getTile(MAP_DEFAULT_GRASS)
        
        for row in range(MAP_ROWS):
            for col in range(MAP_COLS):
                pos = (col * TILESET_TILE_HEIGHT, row * TILESET_TILE_WIDTH)
                tile = Tile(pos, tileImg, MAP_DEFAULT_GRASS)
                self.arMapTiles.append(tile)
                self.surface.blit(tile.image, tile.pos)
                
    def addProp(self, pos, selected):
        """
        Diese Funktion fuegt der Map ein neues Tile hinzu, welches zuvor uber ein Menue ausgewaehlt wurde.
        @param pos: Wird benoetigt, um die richtige Position fuer das neue Tile zu ermitteln
        @param selected: Das Tile, welches gezeichnet werden soll.
        """
        calculateTilePosition = ((pos[0] - self.x) // TILESET_TILE_WIDTH, (pos[1] - self.y) // TILESET_TILE_HEIGHT)
        newPropTile = Tile(calculateTilePosition, selected.image, selected.id, SOLIDS[selected.id])
        self.arMapProps.append(newPropTile)
       
    def delProp(self, pos):
        calculateTilePosition = ((pos[0] - self.x) // TILESET_TILE_WIDTH, (pos[1] - self.y) // TILESET_TILE_HEIGHT)
        for elem in self.arMapProps:
            if elem.pos == calculateTilePosition:
                self.arMapProps.remove(elem)
                
        
            
    def update(self):
        """
        Hier wird geschaut, ob WASD gedrueckt werden. Ist das der Fall bewegt sich die Map in die entsprechende Richtung.
        """
        keys = pygame.key.get_pressed()
        
        if not self.y + (MAP_ROWS - 5) * TILESET_TILE_HEIGHT <= 0:
            if keys[pygame.K_w]:
                self.y -= MAP_SPEED
                
        if not self.y + 5 * TILESET_TILE_HEIGHT >= GAMELOGIC_SCREEN_HEIGHT:    
            if keys[pygame.K_s]:
                self.y += MAP_SPEED
            
        if not self.x + (MAP_ROWS - 5) * TILESET_TILE_WIDTH <= 0:               
            if keys[pygame.K_a]:
                self.x -= MAP_SPEED
                
        if not self.x + 5 * TILESET_TILE_WIDTH >= GAMELOGIC_SCREEN_WIDTH:               
            if keys[pygame.K_d]:
                self.x += MAP_SPEED
                
        self.worker.update()
    
    def renderProps(self):
        self.surfaceProps.fill(COLOR_BLACK)
        for elem in self.arMapProps:
            self.surfaceProps.blit(elem.image, (elem.pos[0] * TILESET_TILE_WIDTH, elem.pos[1] * TILESET_TILE_HEIGHT))
            
        # for elem in self.arAstar:
            # self.surfaceProps.blit(elem.image, (elem.pos[0] * TILESET_TILE_WIDTH, elem.pos[1] * TILESET_TILE_HEIGHT))
        
              
    def render(self, gLogic):
        """
        Zeichnen der aktuellen Maps
        @param gLogic: GameLogic-Referenz
        """
        self.renderProps()
        
        gLogic.screen.blit(self.surface, (self.x, self.y))
        gLogic.screen.blit(self.surfaceProps, (self.x, self.y))
                
                
                
                
        
        
        
